Swfit-01.可变参数,多重可选项，MemoryLayout。。。

• 1. Playground支持Markup(类似Markdown)语言书写注释。

  //: [上一页](@previous): 上一页
  //: [下一页](@next): 下一页
  #：几个对应几级标题
  -：无序标题
  1.：有序标题
  >：笔记
  ---：分割线
  [图片上传失败...(image-16af49-1606451751395)]：图片
  [blog](http://blogzhou.top)：连接
  ** bold **：粗体
  * italic *：斜体

• 2. Let :不要求在编译时确定，但使用前必须赋值。也就是实例初始化前必须有值，(存储类型属性除外)

  // 下面代码错误，因声明时未指明常量类型
  let age
  age = 18

• #####3. 可变参数
  public func print(_ items: Any..., separator: String = " ", terminator: String = "\n")：形如 Any… 为可变参数

• #####4. 函数可作为参数和返回值。

  // 作为参数
  
  func sum(v1: Int, v2: Int) -> Int { 
      v1 + v2
  }
  func difference(v1: Int, v2: Int) -> Int {
      v1 - v2
  }
  func printResult(_ mathFn: (Int, Int) -> Int, _ a: Int, _ b: Int) { 
      print("Result: \(mathFn(a, b))")
  }
  printResult(sum, 5, 2) // Result: 7
  printResult(difference, 5, 2) // Result: 3
  
  ----------------------------------------------------------------------------------------------------------
  
  // 作为返回值
  
  func next(_ input: Int) -> Int { 
      input + 1
  }
  func previous(_ input: Int) -> Int {
      input - 1 
  }
  func forward(_ forward: Bool) -> (Int) -> Int { 
      forward ? next : previous
  }
  forward(true)(3) // 4
  forward(false)(3) // 2
  n返回值是函数类型的函数，叫做高阶函数(Higher-Order Function)

• 5. 方法

  // 嵌套函数。
   func forward(_ forward: Bool) -> (Int) -> Int { 
      func next(_ input: Int) -> Int {
          input + 1 
      }
      func previous(_ input: Int) -> Int {
         input - 1
      }
      return forward ? next : previous
  }
  forward(true)(3) // 4
  forward(false)(3) // 2

• 将方法赋值给var\let
  方法也可以像函数那样，赋值给一个let或者var

  struct Person {
      var age: Int
    func run(_ v: Int) { print("func run", age, v) }
    static func run(_ v: Int) { 
      print("static func run", v) 
    } 
  }
  
  let fn1 = Person.run
  fn1(10) // static func run 10
  let fn2: (Int) -> () = Person.run fn2(20) // static func run 20
  let fn3: (Person) -> ((Int) -> ()) = Person.run 
  fn3(Person(age: 18))(30) // func run 18 30

• 6. 枚举。

• 关联值(Associated Values)

  • 有时将枚举的成员值跟其他类型的值关联存储在一起，会非常有用

    enum Score {
        case points(Int)
        case grade(Character)
    }
    
    var score = Score.points(96) 
    score = .grade("A")
    
    switch score {
      case let .points(i):
        print(i, "points") 
      case let .grade(i):
          print("grade", i)
    } // grade A

• 递归枚举：

  // indirect修饰
  indirect enum ArithExpr {
      case number(Int)
      case sum(ArithExpr, ArithExpr)
      case difference(ArithExpr, ArithExpr)
  }
  
  enum ArithExpr {
      case number(Int)
      indirect case sum(ArithExpr, ArithExpr) 
      indirect case difference(ArithExpr, ArithExpr)
  }
  let five = ArithExpr.number(5)
  let four = ArithExpr.number(4)
  let two = ArithExpr.number(2)
  let sum = ArithExpr.sum(five, four)
  let difference = ArithExpr.difference(sum, two)
  
  func calculate(_ expr: ArithExpr) -> Int { 
      switch expr {
        case let .number(value): 
            return value
        case let .sum(left, right):
            return calculate(left) + calculate(right)
        case let .difference(left, right):
             return calculate(left) - calculate(right)
      } 
  }
  calculate(difference)

• 7. 可以使用MemoryLayout获取数据类型占用的内存大小

  enum Password {
      case number(Int, Int, Int, Int)
      case other
  } 
  
  MemoryLayout<Password>.stride // 40, 分配占用的空间大小 
  MemoryLayout<Password>.size // 33, 实际用到的空间大小 
  MemoryLayout<Password>.alignment // 8, 对齐参数
  
  var pwd = Password.number(9, 8, 6, 4)
  pwd = .other 
  MemoryLayout.stride(ofValue: pwd) // 40 
  MemoryLayout.size(ofValue: pwd) // 33
  MemoryLayout.alignment(ofValue: pwd) // 8

• 8. 可选项(Optional)

  // n 可选项，一般也叫可选类型，它允许将值设置为nil 
  // n在类型名称后面加个问号? 来定义一个可选项
  var name: String? = "Jack"
  name = nil
  var age: Int? // 默认就是nil 
  age = 10
  age = nil
  var array = [1, 15, 40, 29] 
  func get(_ index: Int) -> Int? {
      if index < 0 || index >= array.count { 
          return nil
      }
      return array[index]
  } 
  print(get(1)) // Optional(15)
  print(get(-1)) // nil 
  print(get(4)) // nil

• 可选项是对其他类型的一层包装，可以将它理解为一个盒子

  • 如果为nil，那么它是个空盒子
  • 如果不为nil，那么盒子里装的是:被包装类型的数据
  • • 

• 如果要从可选项中取出被包装的数据(将盒子里装的东西取出来)，需要使用感叹号! 进行强制解包

  • 如果对值为nil的可选项(空盒子)进行强制解包，将会产生运行时错误
    var age: Int?
    age!
    Fatal error: Unexpectedly found nil while unwrapping an Optional value

多重可选项

var num1: Int? = 10
var num2: Int?? = num1
var num3: Int?? = 10
 
print(num2 == num3) // true

var num1: Int? = nil
var num2: Int?? = num1
var num3: Int?? = nil
// num2中装的是个可选类型，num3中装的是nil，所以不相等。
print(num2 == num3) // false
(num2 ?? 1) ?? 2 // 2
(num3 ?? 1) ?? 2 // 1

• 9. 空合并运算符 ??(Nil-Coalescing Operator)

  public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T?) rethrows -> T?
  
  public func ?? <T>(optional: T?, defaultValue: @autoclosure () throws -> T) rethrows -> T

a ?? b
a 是可选项
b 是可选项 或者 不是可选项
b 跟 a 的存储类型必须相同
如果 a 不为nil，就返回 a
如果 a 为nil，就返回 b
如果 b 不是可选项，返回 a 时会自动解包

• 10. 类 和 结构体

  • 类：引用类型，内存在堆上，默认只有一个无参的初始化器（定义成员时指定了初始化值，否则一个没有）。
  • 结构体：值类型，内存根据代码定义的地方不同而不同，默认有好多个初始化器。